import axios from 'axios'
import { message } from 'ant-design-vue'

// 保持大整数ID精度的最佳实践
// 在axios的转换拦截器中处理

// 创建 Axios 实例
const requests = axios.create({
  baseURL: 'http://localhost:8080/api',
  timeout: 60000,
  withCredentials: true,
  // 最关键：拦截原始响应文本进行处理
  transformResponse: [(data) => {
    // 如果不是字符串，无法处理
    if (typeof data !== 'string') {
      return data;
    }

    try {
      // 使用正则表达式直接修复数字精度问题
      // 匹配JSON中的ID字段值（数字）
      const idPatterns = [
        /"id"\s*:\s*(\d{15,})/g,           // "id": 12345678901234567
        /"appId"\s*:\s*(\d{15,})/g,        // "appId": 12345678901234567
        /"userId"\s*:\s*(\d{15,})/g,       // "userId": 12345678901234567
        /"createTime"\s*:\s*(\d{15,})/g,   // 其他可能的大数值字段
        /"updateTime"\s*:\s*(\d{15,})/g
      ];

      // 对每个模式进行替换
      let processedData = data;
      idPatterns.forEach(pattern => {
        processedData = processedData.replace(pattern, (match, numStr) => {
          // 将匹配到的数字部分转换为字符串形式
          return match.replace(numStr, `"${numStr}"`);
        });
      });

      // 尝试解析处理后的JSON文本
      try {
        return JSON.parse(processedData);
      } catch (parseError) {
        console.error('处理后的JSON解析失败', parseError);
        // 如果解析失败，返回原始修正的文本，让其他地方尝试解析
        return processedData;
      }
    } catch (error) {
      console.error('响应文本处理失败', error);
      return data; // 出错时返回原始数据
    }
  }]
})

// 全局请求拦截器
requests.interceptors.request.use(
  function (config) {
    // 将大整数ID转换为字符串格式
    if (config.data && typeof config.data === 'object') {
      const processObject = (obj: any): void => {
        if (!obj || typeof obj !== 'object') return;
        
        Object.keys(obj).forEach(key => {
          // 可能是大整数的ID字段
          if (['id', 'appId', 'userId'].includes(key) && typeof obj[key] === 'number') {
            obj[key] = String(obj[key]);
          } else if (typeof obj[key] === 'object') {
            processObject(obj[key]);
          }
        });
      };
      
      processObject(config.data);
    }
    return config;
  },
  function (error) {
    return Promise.reject(error);
  }
)

// 全局响应拦截器
requests.interceptors.response.use(
  function (response) {
    // 最后一道防线：确保响应数据中的ID是字符串
    if (response.data && typeof response.data === 'object') {
      const ensureIdIsString = (obj: any): void => {
        if (!obj || typeof obj !== 'object') return;
        
        // 处理对象
        if (!Array.isArray(obj)) {
          Object.keys(obj).forEach(key => {
            // ID字段转为字符串
            if (['id', 'appId', 'userId'].includes(key)) {
              if (typeof obj[key] === 'number') {
                const numStr = String(obj[key]);
                const originalStr = numStr;
                obj[key] = numStr;
                
                // 检测并记录潜在的精度问题
                if (numStr.length >= 15) {
                  console.warn(`可能的ID精度问题 - ${key}: ${originalStr}`);
                }
              }
            } 
            // 递归处理嵌套对象
            else if (typeof obj[key] === 'object' && obj[key] !== null) {
              ensureIdIsString(obj[key]);
            }
          });
        } 
        // 处理数组
        else {
          obj.forEach((item: any) => {
            if (typeof item === 'object' && item !== null) {
              ensureIdIsString(item);
            }
          });
        }
      };
      
      ensureIdIsString(response.data);
    }
    
    const { data } = response;
    // 未登录
    if (data && data.code === 40100) {
      // 不是获取用户信息的请求，并且用户目前不是已经在用户登录页面，则跳转到登录页面
      if (
        !response.request.responseURL.includes('user/get/login') &&
        !window.location.pathname.includes('/user/login')
      ) {
        message.warning('请先登录');
        window.location.href = `/user/login?redirect=${window.location.href}`;
      }
    }
    return response;
  },
  function (error) {
    return Promise.reject(error);
  }
)

// 添加全局axios响应体检查，输出调试信息
if (import.meta.env.MODE !== 'production') {
  requests.interceptors.response.use(
    response => {
      try {
        // 输出网络请求调试信息
        const url = response.config.url;
        if (url && (url.includes('/app/') || url.includes('/list/page/vo'))) {
          console.group(`API响应 - ${url}`);
          console.log('原始响应URL:', response.request.responseURL);
          
          // 检查大整数ID的精度
          const checkBigInts = (obj: any, path = ''): void => {
            if (!obj || typeof obj !== 'object') return;
            
            // 检查对象的键值对
            Object.entries(obj).forEach(([key, value]) => {
              const currentPath = path ? `${path}.${key}` : key;
              
              // 重点关注ID字段
              if (['id', 'appId', 'userId'].includes(key)) {
                console.log(`${currentPath} = ${value} (${typeof value})`);
                
                // 严格检查ID值
                if (typeof value === 'number' && String(value).length > 15) {
                  console.error(`‼️ 严重精度问题: ${currentPath} = ${value}, 正确应为字符串`);
                }
                else if (typeof value === 'string' && value.length > 15) {
                  console.log(`✓ 正确ID格式: ${currentPath} = ${value} (字符串)`);
                }
              }
              
              // 递归检查子对象或数组
              if (typeof value === 'object' && value !== null) {
                checkBigInts(value, currentPath);
              }
            });
            
            // 检查数组
            if (Array.isArray(obj)) {
              obj.forEach((item, index) => {
                if (typeof item === 'object' && item !== null) {
                  checkBigInts(item, `${path}[${index}]`);
                }
              });
            }
          };
          
          // 执行检查
          checkBigInts(response.data);
          console.groupEnd();
        }
      } catch (e) {
        console.error('调试数据时出错:', e);
      }
      return response;
    }
  );
}

export default requests
